/** @preserve
 The MIT License (MIT)

 Copyright (c) 2015 yWorks GmbH

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */

/**
 * Renders an svg element to a jsPDF document.
 * For accurate results a DOM document is required (mainly used for text size measurement and image format conversion)
 * @param element {HTMLElement} The svg element, which will be cloned, so the original stays unchanged.
 * @param pdf {jsPDF} The jsPDF object.
 * @param options {object} An object that may contain render options. Currently supported are:
 *                         scale: The global factor by which everything is scaled.
 *                         xOffset, yOffset: Offsets that are added to every coordinate AFTER scaling (They are not
 *                            influenced by the scale attribute).
 */
(function (global) {
    var RGBColor;

    var _pdf; // jsPDF pdf-document

    var cToQ = 2 / 3; // ratio to convert quadratic bezier curves to cubic ones

    // pathSegList is marked deprecated in chrome, so parse the d attribute manually if necessary
    var getPathSegList = function (node) {
        var pathSegList = node.pathSegList;
        if (pathSegList) {
            return pathSegList;
        }

        pathSegList = [];

        var d = node.getAttribute("d");

        var regex = /([a-df-zA-DF-Z])([^a-df-zA-DF-Z]*)/g,
            match;
        while (match = regex.exec(d)) {
            var coords = parseFloats(match[2]);

            var type = match[1];
            var length = "zZ".indexOf(type) >= 0 ? 0 :
                "hHvV".indexOf(type) >= 0 ? 1 :
                    "mMlLtT".indexOf(type) >= 0 ? 2 :
                        "sSqQ".indexOf(type) >= 0 ? 4 :
                            "cC".indexOf(type) >= 0 ? 6 : -1;

            var i = 0;
            do {
                var pathSeg = {pathSegTypeAsLetter: type};
                switch (type) {
                    case "h":
                    case "H":
                        pathSeg.x = coords[i];
                        break;

                    case "v":
                    case "V":
                        pathSeg.y = coords[i];
                        break;

                    case "c":
                    case "C":
                        pathSeg.x1 = coords[i + length - 6];
                        pathSeg.y1 = coords[i + length - 5];
                    case "s":
                    case "S":
                        pathSeg.x2 = coords[i + length - 4];
                        pathSeg.y2 = coords[i + length - 3];
                    case "t":
                    case "T":
                    case "l":
                    case "L":
                    case "m":
                    case "M":
                        pathSeg.x = coords[i + length - 2];
                        pathSeg.y = coords[i + length - 1];
                        break;

                    case "q":
                    case "Q":
                        pathSeg.x1 = coords[i];
                        pathSeg.y1 = coords[i + 1];
                        pathSeg.x = coords[i + 2];
                        pathSeg.y = coords[i + 3];
                        break;
                    // TODO: a,A
                }

                pathSegList.push(pathSeg);
                i += length;
            } while (i < coords.length);
        }

        pathSegList.getItem = function (i) {
            return this[i]
        };
        pathSegList.numberOfItems = pathSegList.length;

        return pathSegList;
    };

    // returns an attribute of a node, either from the node directly or from css
    var getAttribute = function (node, propertyNode, propertyCss) {
        propertyCss = propertyCss || propertyNode;
        return node.getAttribute(propertyNode) || node.style[propertyCss];
    };

    var nodeIs = function (node, tagsString) {
        return tagsString.split(",").indexOf(node.tagName.toLowerCase()) >= 0;
    };

    var forEachChild = function (node, fn) {
        // copy list of children, as the original might be modified
        var children = [];
        for (var i = 0; i < node.childNodes.length; i++) {
            var childNode = node.childNodes[i];
            if (childNode.nodeName.charAt(0) !== "#")
                children.push(childNode);
        }
        for (i = 0; i < children.length; i++) {
            fn(i, children[i]);
        }
    };

    var getAngle = function (from, to) {
        return Math.atan2(to[1] - from[1], to[0] - from[0]);
    };

    // mirrors p1 at p2
    var mirrorPoint = function (p1, p2) {
        var dx = p2[0] - p1[0];
        var dy = p2[1] - p1[1];

        return [p1[0] + 2 * dx, p1[1] + 2 * dy];
    };

    // transforms a cubic bezier control point to a quadratic one: returns from + (2/3) * (to - from)
    var toCubic = function (from, to) {
        return [cToQ * (to[0] - from[0]) + from[0], cToQ * (to[1] - from[1]) + from[1]];
    };

    // extracts a control point from a previous path segment (for t,T,s,S segments)
    var getControlPointFromPrevious = function (i, from, list, prevX, prevY) {
        var prev = list.getItem(i - 1);
        var p2;
        if (i > 0 && (prev.pathSegTypeAsLetter === "C" || prev.pathSegTypeAsLetter === "S")) {
            p2 = mirrorPoint([prev.x2, prev.y2], from);
        } else if (i > 0 && (prev.pathSegTypeAsLetter === "c" || prev.pathSegTypeAsLetter === "s")) {
            p2 = mirrorPoint([prev.x2 + prevX, prev.y2 + prevY], from);
        } else {
            p2 = [from[0], from[1]];
        }
        return p2;
    };

    // an id prefix to handle duplicate ids
    var SvgPrefix = function (prefix) {
        this.prefix = prefix;
        this.id = 0;
        this.nextChild = function () {
            return new SvgPrefix("_" + this.id++ + "_" + this.get());
        };
        this.get = function () {
            return this.prefix;
        }
    };

    // returns the node for the specified id or incrementally removes prefixes to search "higher" levels
    var getFromDefs = function (id, defs) {
        var regExp = /_\d+_/;
        while (!defs[id] && regExp.exec(id)) {
            id = id.replace(regExp, "");
        }
        return defs[id];
    };

    // replace any newline characters by space and trim
    var removeNewlinesAndTrim = function (str) {
        return str.replace(/[\n\s\r]+/, " ").trim();
    };

    // clones the defs object (or basically any object)
    var cloneDefs = function (defs) {
        var clone = {};
        for (var key in defs) {
            if (defs.hasOwnProperty(key)) {
                clone[key] = defs[key];
            }
        }
        return clone;
    };

    // computes the transform directly applied at the node (such as viewbox scaling and the "transform" atrribute)
    // x,y,cx,cy,r,... are omitted
    var computeNodeTransform = function (node) {
        var height, width, viewBoxHeight, viewBoxWidth, bounds, viewBox, y, x;
        var nodeTransform = _pdf.unitMatrix;
        if (nodeIs(node, "svg,g")) {
            x = parseFloat(node.getAttribute("x")) || 0;
            y = parseFloat(node.getAttribute("y")) || 0;

            // jquery doesn't like camelCase notation...
            viewBox = node.getAttribute("viewBox");
            if (viewBox) {
                bounds = parseFloats(viewBox);
                viewBoxWidth = bounds[2] - bounds[0];
                viewBoxHeight = bounds[3] - bounds[1];
                width = parseFloat(node.getAttribute("width")) || viewBoxWidth;
                height = parseFloat(node.getAttribute("height")) || viewBoxHeight;
                nodeTransform = new _pdf.Matrix(width / viewBoxWidth, 0, 0, height / viewBoxHeight, x - bounds[0], y - bounds[1]);
            } else {
                nodeTransform = new _pdf.Matrix(1, 0, 0, 1, x, y);
            }
        } else if (nodeIs(node, "marker")) {
            x = -parseFloat(node.getAttribute("refX")) || 0;
            y = -parseFloat(node.getAttribute("refY")) || 0;

            viewBox = node.getAttribute("viewBox");
            if (viewBox) {
                bounds = parseFloats(viewBox);
                viewBoxWidth = bounds[2] - bounds[0];
                viewBoxHeight = bounds[3] - bounds[1];
                width = parseFloat(node.getAttribute("markerWidth")) || viewBoxWidth;
                height = parseFloat(node.getAttribute("markerHeight")) || viewBoxHeight;

                var s = new _pdf.Matrix(width / viewBoxWidth, 0, 0, height / viewBoxHeight, 0, 0);
                var t = new _pdf.Matrix(1, 0, 0, 1, x, y);
                nodeTransform = _pdf.matrixMult(t, s);
            } else {
                nodeTransform = new _pdf.Matrix(1, 0, 0, 1, x, y);
            }
        }

        var transformString = node.getAttribute("transform");
        if (!transformString)
            return nodeTransform;
        else
            return _pdf.matrixMult(nodeTransform, parseTransform(transformString));
    };

    // parses the "points" string used by polygons and returns an array of points
    var parsePointsString = function (string) {
        var floats = parseFloats(string);
        var result = [];
        for (var i = 0; i < floats.length - 1; i += 2) {
            var x = floats[i];
            var y = floats[i + 1];
            result.push([x, y]);
        }
        return result;
    };

    // parses the "transform" string
    var parseTransform = function (transformString) {
        if (!transformString)
            return _pdf.unitMatrix;

        var mRegex = /^\s*matrix\(([^\)]+)\)\s*/,
            tRegex = /^\s*translate\(([^\)]+)\)\s*/,
            rRegex = /^\s*rotate\(([^\)]+)\)\s*/,
            sRegex = /^\s*scale\(([^\)]+)\)\s*/,
            sXRegex = /^\s*skewX\(([^\)]+)\)\s*/,
            sYRegex = /^\s*skewY\(([^\)]+)\)\s*/;

        var resultMatrix = _pdf.unitMatrix, m;

        while (transformString.length > 0) {
            var match = mRegex.exec(transformString);
            if (match) {
                m = parseFloats(match[1]);
                resultMatrix = _pdf.matrixMult(new _pdf.Matrix(m[0], m[1], m[2], m[3], m[4], m[5]), resultMatrix);
                transformString = transformString.substr(match[0].length);
            }
            match = rRegex.exec(transformString);
            if (match) {
                m = parseFloats(match[1]);
                var a = Math.PI * m[0] / 180;
                resultMatrix = _pdf.matrixMult(new _pdf.Matrix(Math.cos(a), Math.sin(a), -Math.sin(a), Math.cos(a), 0, 0), resultMatrix);
                if (m[1] && m[2]) {
                    var t1 = new _pdf.Matrix(1, 0, 0, 1, m[1], m[2]);
                    var t2 = new _pdf.Matrix(1, 0, 0, 1, -m[1], -m[2]);
                    resultMatrix = _pdf.matrixMult(t2, _pdf.matrixMult(resultMatrix, t1));
                }
                transformString = transformString.substr(match[0].length);
            }
            match = tRegex.exec(transformString);
            if (match) {
                m = parseFloats(match[1]);
                resultMatrix = _pdf.matrixMult(new _pdf.Matrix(1, 0, 0, 1, m[0], m[1] || 0), resultMatrix);
                transformString = transformString.substr(match[0].length);
            }
            match = sRegex.exec(transformString);
            if (match) {
                m = parseFloats(match[1]);
                if (!m[1])
                    m[1] = m[0];
                resultMatrix = _pdf.matrixMult(new _pdf.Matrix(m[0], 0, 0, m[1], 0, 0), resultMatrix);
                transformString = transformString.substr(match[0].length);
            }
            match = sXRegex.exec(transformString);
            if (match) {
                m = parseFloat(match[1]);
                resultMatrix = _pdf.matrixMult(new _pdf.Matrix(1, 0, Math.tan(m), 1, 0, 0), resultMatrix);
                transformString = transformString.substr(match[0].length);
            }
            match = sYRegex.exec(transformString);
            if (match) {
                m = parseFloat(match[1]);
                resultMatrix = _pdf.matrixMult(new _pdf.Matrix(1, Math.tan(m), 0, 1, 0, 0), resultMatrix);
                transformString = transformString.substr(match[0].length);
            }
        }
        return resultMatrix;
    };

    // parses a comma, sign and/or whitespace separated string of floats and returns the single floats in an array
    var parseFloats = function (str) {
        var floats = [], match,
            regex = /[+-]?(?:(?:\d+\.?\d*)|(?:\d*\.?\d+))(?:[eE][+-]?\d+)?/g;
        while (match = regex.exec(str)) {
            floats.push(parseFloat(match[0]));
        }
        return floats;
    };

    // extends RGBColor by rgba colors as RGBColor is not capable of it
    var parseColor = function (colorString) {
        var match = /\s*rgba\(((?:[^,\)]*,){3}[^,\)]*)\)\s*/.exec(colorString);
        if (match) {
            var floats = parseFloats(match[1]);
            var color = new RGBColor("rgb(" + floats.slice(0, 3).join(",") + ")");
            color.a = floats[3];
            return color;
        } else {
            return new RGBColor(colorString);
        }
    };

    // multiplies a vector with a matrix: vec' = vec * matrix
    var multVecMatrix = function (vec, matrix) {
        var x = vec[0];
        var y = vec[1];
        return [
            matrix.a * x + matrix.c * y + matrix.e,
            matrix.b * x + matrix.d * y + matrix.f
        ];
    };

    // returns the untransformed bounding box [x, y, width, height] of an svg element (quite expensive for path and polygon objects, as
    // the whole points/d-string has to be processed)
    var getUntransformedBBox = function (node) {
        var i, minX, minY, maxX, maxY, viewBox, vb, boundingBox;
        var pf = parseFloat;

        if (nodeIs(node, "polygon")) {
            var points = parsePointsString(node.getAttribute("points"));
            minX = Number.POSITIVE_INFINITY;
            minY = Number.POSITIVE_INFINITY;
            maxX = Number.NEGATIVE_INFINITY;
            maxY = Number.NEGATIVE_INFINITY;
            for (i = 0; i < points.length; i++) {
                var point = points[i];
                minX = Math.min(minX, point[0]);
                maxX = Math.max(maxX, point[0]);
                minY = Math.min(minY, point[1]);
                maxY = Math.max(maxY, point[1]);
            }
            boundingBox = [
                minX,
                minY,
                maxX - minX,
                maxY - minY
            ];
        } else if (nodeIs(node, "path")) {
            var list = getPathSegList(node);
            minX = Number.POSITIVE_INFINITY;
            minY = Number.POSITIVE_INFINITY;
            maxX = Number.NEGATIVE_INFINITY;
            maxY = Number.NEGATIVE_INFINITY;
            var x = 0, y = 0;
            var prevX, prevY, newX, newY;
            var p2, p3, to;
            for (i = 0; i < list.numberOfItems; i++) {
                var seg = list.getItem(i);
                var cmd = seg.pathSegTypeAsLetter;
                switch (cmd) {
                    case "H":
                        newX = seg.x;
                        newY = y;
                        break;
                    case "h":
                        newX = seg.x + x;
                        newY = y;
                        break;
                    case "V":
                        newX = x;
                        newY = seg.y;
                        break;
                    case "v":
                        newX = x;
                        newY = seg.y + y;
                        break;
                    case "C":
                        p2 = [seg.x1, seg.y1];
                        p3 = [seg.x2, seg.y2];
                        to = [seg.x, seg.y];
                        break;
                    case "c":
                        p2 = [seg.x1 + x, seg.y1 + y];
                        p3 = [seg.x2 + x, seg.y2 + y];
                        to = [seg.x + x, seg.y + y];
                        break;
                    case "S":
                        p2 = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
                        p3 = [seg.x2, seg.y2];
                        to = [seg.x, seg.y];
                        break;
                    case "s":
                        p2 = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
                        p3 = [seg.x2 + x, seg.y2 + y];
                        to = [seg.x + x, seg.y + y];
                        break;
                    case "Q":
                        pf = [seg.x1, seg.y1];
                        p2 = toCubic([x, y], pf);
                        p3 = toCubic([seg.x, seg.y], pf);
                        to = [seg.x, seg.y];
                        break;
                    case "q":
                        pf = [seg.x1 + x, seg.y1 + y];
                        p2 = toCubic([x, y], pf);
                        p3 = toCubic([x + seg.x, y + seg.y], pf);
                        to = [seg.x + x, seg.y + y];
                        break;
                    case "T":
                        p2 = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
                        p2 = toCubic([x, y], pf);
                        p3 = toCubic([seg.x, seg.y], pf);
                        to = [seg.x, seg.y];
                        break;
                    case "t":
                        pf = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
                        p2 = toCubic([x, y], pf);
                        p3 = toCubic([x + seg.x, y + seg.y], pf);
                        to = [seg.x + x, seg.y + y];
                        break;
                    // TODO: A,a
                }
                if ("sScCqQtT".indexOf(cmd) >= 0) {
                    prevX = x;
                    prevY = y;
                }
                if ("MLCSQT".indexOf(cmd) >= 0) {
                    x = seg.x;
                    y = seg.y;
                } else if ("mlcsqt".indexOf(cmd) >= 0) {
                    x = seg.x + x;
                    y = seg.y + y;
                } else if ("zZ".indexOf(cmd) < 0) {
                    x = newX;
                    y = newY;
                }
                if ("CSQTcsqt".indexOf(cmd) >= 0) {
                    minX = Math.min(minX, x, p2[0], p3[0], to[0]);
                    maxX = Math.max(maxX, x, p2[0], p3[0], to[0]);
                    minY = Math.min(minY, y, p2[1], p3[1], to[1]);
                    maxY = Math.max(maxY, y, p2[1], p3[1], to[1]);
                } else {
                    minX = Math.min(minX, x);
                    maxX = Math.max(maxX, x);
                    minY = Math.min(minY, y);
                    maxY = Math.max(maxY, y);
                }
            }
            boundingBox = [
                minX,
                minY,
                maxX - minX,
                maxY - minY
            ];
        } else if (nodeIs(node, "svg")) {
            viewBox = node.getAttribute("viewBox");
            if (viewBox) {
                vb = parseFloats(viewBox);
            }
            return [
                pf(node.getAttribute("x")) || (vb && vb[0]) || 0,
                pf(node.getAttribute("y")) || (vb && vb[1]) || 0,
                pf(node.getAttribute("width")) || (vb && vb[2]) || 0,
                pf(node.getAttribute("height")) || (vb && vb[3]) || 0
            ];
        } else if (nodeIs(node, "g")) {
            boundingBox = [0, 0, 0, 0];
            forEachChild(node, function (i, node) {
                var nodeBox = getUntransformedBBox(node);
                boundingBox = [
                    Math.min(boundingBox[0], nodeBox[0]),
                    Math.min(boundingBox[1], nodeBox[1]),
                    Math.max(boundingBox[0] + boundingBox[2], nodeBox[0] + nodeBox[2]) - Math.min(boundingBox[0], nodeBox[0]),
                    Math.max(boundingBox[1] + boundingBox[3], nodeBox[1] + nodeBox[3]) - Math.min(boundingBox[1], nodeBox[1])
                ];
            });
        } else if (nodeIs(node, "marker")) {
            viewBox = node.getAttribute("viewBox");
            if (viewBox) {
                vb = parseFloats(viewBox);
            }
            return [
                (vb && vb[0]) || 0,
                (vb && vb[1]) || 0,
                (vb && vb[2]) || pf(node.getAttribute("marker-width")) || 0,
                (vb && vb[3]) || pf(node.getAttribute("marker-height")) || 0
            ];
        } else if (nodeIs(node, "pattern")) {
            return [
                pf(node.getAttribute("x")) || 0,
                pf(node.getAttribute("y")) || 0,
                pf(node.getAttribute("width")) || 0,
                pf(node.getAttribute("height")) || 0
            ]
        } else {
            // TODO: check if there are other possible coordinate attributes
            var x1 = pf(node.getAttribute("x1")) || pf(node.getAttribute("x")) || pf((node.getAttribute("cx")) - pf(node.getAttribute("r"))) || 0;
            var x2 = pf(node.getAttribute("x2")) || (x1 + pf(node.getAttribute("width"))) || (pf(node.getAttribute("cx")) + pf(node.getAttribute("r"))) || 0;
            var y1 = pf(node.getAttribute("y1")) || pf(node.getAttribute("y")) || (pf(node.getAttribute("cy")) - pf(node.getAttribute("r"))) || 0;
            var y2 = pf(node.getAttribute("y2")) || (y1 + pf(node.getAttribute("height"))) || (pf(node.getAttribute("cy")) + pf(node.getAttribute("r"))) || 0;
            boundingBox = [
                Math.min(x1, x2),
                Math.min(y1, y2),
                Math.max(x1, x2) - Math.min(x1, x2),
                Math.max(y1, y2) - Math.min(y1, y2)
            ];
        }

        if (!nodeIs(node, "marker,svg,g")) {
            // add line-width
            var lineWidth = getAttribute(node, "stroke-width") || 1;
            var miterLimit = getAttribute(node, "stroke-miterlimit");
            // miterLength / lineWidth = 1 / sin(phi / 2)
            miterLimit && (lineWidth *= 0.5 / (Math.sin(Math.PI / 12)));
            return [
                boundingBox[0] - lineWidth,
                boundingBox[1] - lineWidth,
                boundingBox[2] + 2 * lineWidth,
                boundingBox[3] + 2 * lineWidth
            ];
        }

        return boundingBox;
    };

    // transforms a bounding box and returns a new rect that contains it
    var transformBBox = function (box, matrix) {
        var bl = multVecMatrix([box[0], box[1]], matrix);
        var br = multVecMatrix([box[0] + box[2], box[1]], matrix);
        var tl = multVecMatrix([box[0], box[1] + box[3]], matrix);
        var tr = multVecMatrix([box[0] + box[2], box[1] + box[3]], matrix);

        var bottom = Math.min(bl[1], br[1], tl[1], tr[1]);
        var left = Math.min(bl[0], br[0], tl[0], tr[0]);
        var top = Math.max(bl[1], br[1], tl[1], tr[1]);
        var right = Math.max(bl[0], br[0], tl[0], tr[0]);

        return [
            left,
            bottom,
            right - left,
            top - bottom
        ]
    };

    // draws a polygon
    var polygon = function (node, tfMatrix, colorMode, gradient, gradientMatrix) {
        var points = parsePointsString(node.getAttribute("points"));
        var lines = [{op: "m", c: multVecMatrix(points[0], tfMatrix)}];
        for (var i = 1; i < points.length; i++) {
            var p = points[i];
            var to = multVecMatrix(p, tfMatrix);
            lines.push({op: "l", c: to});
        }
        lines.push({op: "h"});
        _pdf.path(lines, colorMode, gradient, gradientMatrix);
    };

    // draws an image (converts it to jpeg first, as jsPDF doesn't support png or other formats)
    var image = function (node) {
        // convert image to jpeg
        var imageUrl = node.getAttribute("xlink:href") || node.getAttribute("href");
        var image = new Image();
        image.src = imageUrl;

        var canvas = document.createElement("canvas");
        var width = parseFloat(node.getAttribute("width")),
            height = parseFloat(node.getAttribute("height")),
            x = parseFloat(node.getAttribute("x") || 0),
            y = parseFloat(node.getAttribute("y") || 0);
        canvas.width = width;
        canvas.height = height;
        var context = canvas.getContext("2d");
        context.fillStyle = "#fff";
        context.fillRect(0, 0, width, height);
        context.drawImage(image, 0, 0, width, height);
        var jpegUrl = canvas.toDataURL("image/jpeg");

        _pdf.addImage(jpegUrl,
            "jpeg",
            x,
            y,
            width,
            height
        );
    };

    // draws a path
    var path = function (node, tfMatrix, svgIdPrefix, colorMode, gradient, gradientMatrix) {
        var list = getPathSegList(node);
        var markerEnd = node.getAttribute("marker-end"),
            markerStart = node.getAttribute("marker-start"),
            markerMid = node.getAttribute("marker-mid");

        var getLinesFromPath = function (pathSegList, tfMatrix) {
            var x = 0, y = 0;
            var x0 = x, y0 = y;
            var prevX, prevY, newX, newY;
            var to, p, p2, p3;
            var lines = [];
            var markers = [];
            var op;
            var prevAngle = 0, curAngle;

            var addMarker = function (angle, anchor, type) {
                var cos = Math.cos(angle);
                var sin = Math.sin(angle);
                var tf;
                tf = new _pdf.Matrix(cos, sin, -sin, cos, anchor[0], anchor[1]);
                markers.push({type: type, tf: _pdf.matrixMult(tf, tfMatrix)});
            };

            for (var i = 0; i < list.numberOfItems; i++) {
                var seg = list.getItem(i);
                var cmd = seg.pathSegTypeAsLetter;
                switch (cmd) {
                    case "M":
                        x0 = x;
                        y0 = y;
                        to = [seg.x, seg.y];
                        op = "m";
                        break;
                    case "m":
                        x0 = x;
                        y0 = y;
                        to = [seg.x + x, seg.y + y];
                        op = "m";
                        break;
                    case "L":
                        to = [seg.x, seg.y];
                        op = "l";
                        break;
                    case "l":
                        to = [seg.x + x, seg.y + y];
                        op = "l";
                        break;
                    case "H":
                        to = [seg.x, y];
                        op = "l";
                        newX = seg.x;
                        newY = y;
                        break;
                    case "h":
                        to = [seg.x + x, y];
                        op = "l";
                        newX = seg.x + x;
                        newY = y;
                        break;
                    case "V":
                        to = [x, seg.y];
                        op = "l";
                        newX = x;
                        newY = seg.y;
                        break;
                    case "v":
                        to = [x, seg.y + y];
                        op = "l";
                        newX = x;
                        newY = seg.y + y;
                        break;
                    case "C":
                        p2 = [seg.x1, seg.y1];
                        p3 = [seg.x2, seg.y2];
                        to = [seg.x, seg.y];
                        break;
                    case "c":
                        p2 = [seg.x1 + x, seg.y1 + y];
                        p3 = [seg.x2 + x, seg.y2 + y];
                        to = [seg.x + x, seg.y + y];
                        break;
                    case "S":
                        p2 = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
                        p3 = [seg.x2, seg.y2];
                        to = [seg.x, seg.y];
                        break;
                    case "s":
                        p2 = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
                        p3 = [seg.x2 + x, seg.y2 + y];
                        to = [seg.x + x, seg.y + y];
                        break;
                    case "Q":
                        p = [seg.x1, seg.y1];
                        p2 = toCubic([x, y], p);
                        p3 = toCubic([seg.x, seg.y], p);
                        to = [seg.x, seg.y];
                        break;
                    case "q":
                        p = [seg.x1 + x, seg.y1 + y];
                        p2 = toCubic([x, y], p);
                        p3 = toCubic([x + seg.x, y + seg.y], p);
                        to = [seg.x + x, seg.y + y];
                        break;
                    case "T":
                        p2 = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
                        p2 = toCubic([x, y], p);
                        p3 = toCubic([seg.x, seg.y], p);
                        to = [seg.x, seg.y];
                        break;
                    case "t":
                        p = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
                        p2 = toCubic([x, y], p);
                        p3 = toCubic([x + seg.x, y + seg.y], p);
                        to = [seg.x + x, seg.y + y];
                        break;
                    // TODO: A,a
                    case "Z":
                    case "z":
                        x = x0;
                        y = y0;
                        lines.push({op: "h"});
                        break;
                }

                var hasStartMarker = markerStart
                    && (i === 1
                        || ("mM".indexOf(cmd) < 0 && "mM".indexOf(list.getItem(i - 1).pathSegTypeAsLetter) >= 0));
                var hasEndMarker = markerEnd
                    && (i === list.numberOfItems - 1
                        || ("mM".indexOf(cmd) < 0 && "mM".indexOf(list.getItem(i + 1).pathSegTypeAsLetter) >= 0));
                var hasMidMarker = markerMid
                    && i > 0
                    && !(i === 1 && "mM".indexOf(list.getItem(i - 1).pathSegTypeAsLetter) >= 0);

                if ("sScCqQtT".indexOf(cmd) >= 0) {
                    hasStartMarker && addMarker(getAngle([x, y], p2), [x, y], "start");
                    hasEndMarker && addMarker(getAngle(p3, to), to, "end");
                    if (hasMidMarker) {
                        curAngle = getAngle([x, y], p2);
                        curAngle = "mM".indexOf(list.getItem(i - 1).pathSegTypeAsLetter) >= 0 ?
                            curAngle : .5 * (prevAngle + curAngle);
                        addMarker(curAngle, [x, y], "mid");
                    }

                    prevAngle = getAngle(p3, to);

                    prevX = x;
                    prevY = y;
                    p2 = multVecMatrix(p2, tfMatrix);
                    p3 = multVecMatrix(p3, tfMatrix);
                    p = multVecMatrix(to, tfMatrix);
                    lines.push({
                        op: "c", c: [
                            p2[0], p2[1],
                            p3[0], p3[1],
                            p[0], p[1]
                        ]
                    });
                } else if ("lLhHvVmM".indexOf(cmd) >= 0) {
                    curAngle = getAngle([x, y], to);
                    hasStartMarker && addMarker(curAngle, [x, y], "start");
                    hasEndMarker && addMarker(curAngle, to, "end");
                    if (hasMidMarker) {
                        var angle = "mM".indexOf(cmd) >= 0 ?
                            prevAngle : "mM".indexOf(list.getItem(i - 1).pathSegTypeAsLetter) >= 0 ?
                                curAngle : .5 * (prevAngle + curAngle);
                        addMarker(angle, [x, y], "mid");
                    }
                    prevAngle = curAngle;

                    p = multVecMatrix(to, tfMatrix);
                    lines.push({op: op, c: p});
                }

                if ("MLCSQT".indexOf(cmd) >= 0) {
                    x = seg.x;
                    y = seg.y;
                } else if ("mlcsqt".indexOf(cmd) >= 0) {
                    x = seg.x + x;
                    y = seg.y + y;
                } else if ("zZ".indexOf(cmd) < 0) {
                    x = newX;
                    y = newY;
                }
            }

            return {lines: lines, markers: markers};
        };
        var lines = getLinesFromPath(list, tfMatrix);

        if (markerEnd || markerStart || markerMid) {
            for (var i = 0; i < lines.markers.length; i++) {
                var marker = lines.markers[i];
                var markerElement;
                switch (marker.type) {
                    case "start":
                        markerElement = svgIdPrefix.get() + /url\(#(\w+)\)/.exec(markerStart)[1];
                        break;
                    case "end":
                        markerElement = svgIdPrefix.get() + /url\(#(\w+)\)/.exec(markerEnd)[1];
                        break;
                    case "mid":
                        markerElement = svgIdPrefix.get() + /url\(#(\w+)\)/.exec(markerMid)[1];
                        break;
                }
                _pdf.doFormObject(markerElement, marker.tf);
            }
        }

        if (lines.lines.length > 0) {
            _pdf.path(lines.lines, colorMode, gradient, gradientMatrix);
        }
    };

    // draws the element referenced by a use node, makes use of pdf's XObjects/FormObjects so nodes are only written once
    // to the pdf document. This highly reduces the file size and computation time.
    var use = function (node, tfMatrix, svgIdPrefix) {
        var url = (node.getAttribute("href") || node.getAttribute("xlink:href"));
        // just in case someone has the idea to use empty use-tags, wtf???
        if (!url)
            return;

        // get the size of the referenced form object (to apply the correct scaling)
        var formObject = _pdf.getFormObject(svgIdPrefix.get() + url.substring(1));

        // scale and position it right
        var x = node.getAttribute("x") || 0;
        var y = node.getAttribute("y") || 0;
        var width = node.getAttribute("width") || formObject.width;
        var height = node.getAttribute("height") || formObject.height;
        var t = new _pdf.Matrix(width / formObject.width || 0, 0, 0, height / formObject.height || 0, x, y);
        t = _pdf.matrixMult(t, tfMatrix);
        _pdf.doFormObject(svgIdPrefix.get() + url.substring(1), t);
    };

    // draws a line
    var line = function (node, tfMatrix) {
        var p1 = multVecMatrix([parseFloat(node.getAttribute('x1')), parseFloat(node.getAttribute('y1'))], tfMatrix);
        var p2 = multVecMatrix([parseFloat(node.getAttribute('x2')), parseFloat(node.getAttribute('y2'))], tfMatrix);
        _pdf.line(p1[0], p1[1], p2[0], p2[1]);
    };

    // draws a rect
    var rect = function (node, colorMode, gradient, gradientMatrix) {
        _pdf.roundedRect(
            parseFloat(node.getAttribute('x')) || 0,
            parseFloat(node.getAttribute('y')) || 0,
            parseFloat(node.getAttribute('width')),
            parseFloat(node.getAttribute('height')),
            parseFloat(node.getAttribute('rx')) || 0,
            parseFloat(node.getAttribute('ry')) || 0,
            colorMode,
            gradient,
            gradientMatrix
        );
    };

    // draws an ellipse
    var ellipse = function (node, colorMode, gradient, gradientMatrix) {
        _pdf.ellipse(
            parseFloat(node.getAttribute('cx')) || 0,
            parseFloat(node.getAttribute('cy')) || 0,
            parseFloat(node.getAttribute('rx')),
            parseFloat(node.getAttribute('ry')),
            colorMode,
            gradient,
            gradientMatrix
        );
    };

    // draws a circle
    var circle = function (node, colorMode, gradient, gradientMatrix) {
        var radius = parseFloat(node.getAttribute('r')) || 0;
        _pdf.ellipse(
            parseFloat(node.getAttribute('cx')) || 0,
            parseFloat(node.getAttribute('cy')) || 0,
            radius,
            radius,
            colorMode,
            gradient,
            gradientMatrix
        );
    };

    // applies text transformations to a text node
    var transformText = function (node, text) {
        var textTransform = getAttribute(node, "text-transform");
        switch (textTransform) {
            case "uppercase":
                return text.toUpperCase();
            case "lowercase":
                return text.toLowerCase();
            default:
                return text;
            // TODO: capitalize, full-width
        }
    };

    // draws a text element and its tspan children
    var text = function (node, tfMatrix, hasFillColor, fillRGB) {
        _pdf.saveGraphicsState();
        setTextProperties(node, fillRGB);

        var getTextOffset = function (textAnchor, width) {
            var xOffset = 0;
            switch (textAnchor) {
                case 'end':
                    xOffset = width;
                    break;
                case 'middle':
                    xOffset = width / 2;
                    break;
                case 'start':
                    break;
            }
            return xOffset;
        };

        /**
         * Convert em, px and bare number attributes to pixel values
         */
        var toPixels = function (value, pdfFontSize) {
            var match;

            // em
            match = value && value.toString().match(/^([\-0-9.]+)em$/);
            if (match) {
                return parseFloat(match[1]) * pdfFontSize;
            }

            // pixels
            match = value && value.toString().match(/^([\-0-9.]+)(px|)$/);
            if (match) {
                return parseFloat(match[1]);
            }
            return 0;
        };

        // creates an svg element and append the text node to properly measure the text size
        var svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
        svg.appendChild(node);
        svg.setAttribute("visibility", "hidden");
        document.body.appendChild(svg);

        var box = node.getBBox();
        var x, y, xOffset = 0;
        var textAnchor = getAttribute(node, "text-anchor");
        if (textAnchor) {
            xOffset = getTextOffset(textAnchor, box.width);
        }

        var pdfFontSize = _pdf.getFontSize();
        var textX = toPixels(node.getAttribute('x'), pdfFontSize);
        var textY = toPixels(node.getAttribute('y'), pdfFontSize);
        var m = _pdf.matrixMult(new _pdf.Matrix(1, 0, 0, 1, textX, textY), tfMatrix);

        x = toPixels(node.getAttribute("dx"), pdfFontSize);
        y = toPixels(node.getAttribute("dy"), pdfFontSize);

        // when there are no tspans draw the text directly
        if (node.childElementCount === 0) {
            _pdf.text(
                (x - xOffset),
                y,
                transformText(node, removeNewlinesAndTrim(node.textContent)),
                void 0,
                m
            );
        } else {
            // otherwise loop over tspans and position each relative to the previous one
            forEachChild(node, function (i, tSpan) {
                _pdf.saveGraphicsState();
                var tSpanColor = getAttribute(tSpan, "fill");
                setTextProperties(tSpan, tSpanColor && new RGBColor(tSpanColor));
                var extent = tSpan.getExtentOfChar(0);
                _pdf.text(
                    extent.x - textX,//x - xOffset,
                    extent.y + extent.height * 0.7 - textY, // 0.7 roughly mimicks the text baseline
                    transformText(node, removeNewlinesAndTrim(tSpan.textContent)),
                    void 0,
                    m
                );

                _pdf.restoreGraphicsState();
            });

        }

        document.body.removeChild(svg);
        _pdf.restoreGraphicsState();
    };

    // As defs elements are allowed to appear after they are referenced, we search for them first
    var findAndRenderDefs = function (node, tfMatrix, defs, svgIdPrefix, withinDefs) {
        forEachChild(node, function (i, child) {
            if (child.tagName.toLowerCase() === "defs") {
                renderNode(child, tfMatrix, defs, svgIdPrefix, withinDefs);
                // prevent defs from being evaluated twice // TODO: make this better
                child.parentNode.removeChild(child);
            }
        });
    };

    // processes a svg node
    var svg = function (node, tfMatrix, defs, svgIdPrefix, withinDefs) {
        // create a new prefix and clone the defs, as defs within the svg should not be visible outside
        var newSvgIdPrefix = svgIdPrefix.nextChild();
        var newDefs = cloneDefs(defs);
        findAndRenderDefs(node, tfMatrix, newDefs, newSvgIdPrefix, withinDefs);
        renderChildren(node, tfMatrix, newDefs, newSvgIdPrefix, withinDefs);
    };

    // renders all children of a node
    var renderChildren = function (node, tfMatrix, defs, svgIdPrefix, withinDefs) {
        forEachChild(node, function (i, node) {
            renderNode(node, tfMatrix, defs, svgIdPrefix, withinDefs);
        });
    };

    // adds a gradient to defs and the pdf document for later use, type is either "axial" or "radial"
    // opacity is only supported rudimentary by averaging over all stops
    // transforms are applied on use
    var putGradient = function (node, type, coords, defs, svgIdPrefix) {
        var colors = [];
        var opacitySum = 0;
        var hasOpacity = false;
        var gState;
        forEachChild(node, function (i, element) {
            // since opacity gradients are hard to realize, average the opacity over the control points
            if (element.tagName.toLowerCase() === "stop") {
                var color = new RGBColor(getAttribute(element, "stop-color"));
                colors.push({
                    offset: parseFloat(element.getAttribute("offset")),
                    color: [color.r, color.g, color.b]
                });
                var opacity = getAttribute(element, "stop-opacity");
                if (opacity && opacity != 1) {
                    opacitySum += parseFloat(opacity);
                    hasOpacity = true;
                }
            }
        });

        if (hasOpacity) {
            gState = new _pdf.GState({opacity: opacitySum / coords.length});
        }

        var pattern = new _pdf.ShadingPattern(type, coords, colors, gState);
        var id = svgIdPrefix.get() + node.getAttribute("id");
        _pdf.addShadingPattern(id, pattern);
        defs[id] = node;
    };

    var pattern = function (node, defs, svgIdPrefix) {
        var id = svgIdPrefix.get() + node.getAttribute("id");
        defs[id] = node;

        // the transformations directly at the node are written to the pattern transformation matrix
        var bBox = getUntransformedBBox(node);
        var pattern = new _pdf.TilingPattern([bBox[0], bBox[1], bBox[0] + bBox[2], bBox[1] + bBox[3]], bBox[2], bBox[3],
            null, computeNodeTransform(node));

        _pdf.beginTilingPattern(pattern);
        // continue without transformation
        renderChildren(node, _pdf.unitMatrix, defs, svgIdPrefix, false);
        _pdf.endTilingPattern(id, pattern);
    };

    function setTextProperties(node, fillRGB) {
        var fontFamily = getAttribute(node, "font-family");
        if (fontFamily) {
            _pdf.setFont(fontFamily);
        }

        if (fillRGB && fillRGB.ok) {
            _pdf.setTextColor(fillRGB.r, fillRGB.g, fillRGB.b);
        }

        var fontType;
        var fontWeight = getAttribute(node, "font-weight");
        if (fontWeight) {
            if (fontWeight === "bold") {
                fontType = "bold";
            }
        }

        var fontStyle = getAttribute(node, "font-style");
        if (fontStyle) {
            if (fontStyle === "italic") {
                fontType += "italic";
            }
        }
        _pdf.setFontType(fontType);

        var pdfFontSize = 16;
        var fontSize = getAttribute(node, "font-size");
        if (fontSize) {
            pdfFontSize = parseFloat(fontSize);
            _pdf.setFontSize(pdfFontSize);
        }
    }


    /**
     * Renders a svg node.
     * @param node The svg element
     * @param contextTransform The current transformation matrix
     * @param defs The defs map holding all svg nodes that can be referenced
     * @param svgIdPrefix The current id prefix
     * @param withinDefs True iff we are top-level within a defs node, so the target can be switched to an pdf form object
     */
    var renderNode = function (node, contextTransform, defs, svgIdPrefix, withinDefs) {
        var tfMatrix,
            hasFillColor = false,
            fillRGB = null,
            colorMode = null,
            fillUrl = null,
            fillData = null,
            bBox;

        //
        // Decide about the render target and set the correct transformation
        //

        // if we are within a defs node, start a new pdf form object and draw this node and all children on that instead
        // of the top-level page
        var targetIsFormObject = withinDefs && !nodeIs(node, "lineargradient,radialgradient,pattern");
        if (targetIsFormObject) {

            // the transformations directly at the node are written to the pdf form object transformation matrix
            tfMatrix = computeNodeTransform(node);
            bBox = getUntransformedBBox(node);

            _pdf.beginFormObject(bBox[0], bBox[1], bBox[2], bBox[3], tfMatrix);

            // continue without transformation and set withinDefs to false to prevent child nodes from starting new form objects
            tfMatrix = _pdf.unitMatrix;
            withinDefs = false;

        } else {
            tfMatrix = _pdf.matrixMult(computeNodeTransform(node), contextTransform);
            _pdf.saveGraphicsState();
        }

        //
        // extract fill and stroke mode
        //

        // fill mode
        if (nodeIs(node, "g,path,rect,text,ellipse,line,circle,polygon")) {
            function setDefaultColor() {
                fillRGB = new RGBColor("rgb(0, 0, 0)");
                hasFillColor = true;
                colorMode = "F";
            }

            var fillColor = getAttribute(node, "fill");
            if (fillColor) {
                var url = /url\(#(\w+)\)/.exec(fillColor);
                if (url) {
                    // probably a gradient (or something unsupported)
                    fillUrl = svgIdPrefix.get() + url[1];
                    var fill = getFromDefs(fillUrl, defs);
                    if (fill && nodeIs(fill, "lineargradient,radialgradient")) {

                        // matrix to convert between gradient space and user space
                        // for "userSpaceOnUse" this is the current transformation: tfMatrix
                        // for "objectBoundingBox" or default, the gradient gets scaled and transformed to the bounding box
                        var gradientUnitsMatrix = tfMatrix;
                        if (!fill.hasAttribute("gradientUnits")
                            || fill.getAttribute("gradientUnits").toLowerCase() === "objectboundingbox") {
                            bBox || (bBox = getUntransformedBBox(node));
                            gradientUnitsMatrix = new _pdf.Matrix(bBox[2], 0, 0, bBox[3], bBox[0], bBox[1]);

                            var nodeTransform = computeNodeTransform(node);
                            gradientUnitsMatrix = _pdf.matrixMult(gradientUnitsMatrix, nodeTransform);
                        }

                        // matrix that is applied to the gradient before any other transformations
                        var gradientTransform = parseTransform(fill.getAttribute("gradientTransform"));

                        fillData = _pdf.matrixMult(gradientTransform, gradientUnitsMatrix);
                    } else if (fill && nodeIs(fill, "pattern")) {
                        var fillBBox, y, width, height, x;
                        fillData = {};

                        var patternUnitsMatrix = _pdf.unitMatrix;
                        if (!fill.hasAttribute("patternUnits")
                            || fill.getAttribute("patternUnits").toLowerCase() === "objectboundingbox") {
                            bBox || (bBox = getUntransformedBBox(node));
                            patternUnitsMatrix = new _pdf.Matrix(1, 0, 0, 1, bBox[0], bBox[1]);

                            // TODO: slightly inaccurate (rounding errors? line width bBoxes?)
                            fillBBox = getUntransformedBBox(fill);
                            x = fillBBox[0] * bBox[0];
                            y = fillBBox[1] * bBox[1];
                            width = fillBBox[2] * bBox[2];
                            height = fillBBox[3] * bBox[3];
                            fillData.boundingBox = [x, y, x + width, y + height];
                            fillData.xStep = width;
                            fillData.yStep = height;
                        }

                        var patternContentUnitsMatrix = _pdf.unitMatrix;
                        if (fill.hasAttribute("patternContentUnits")
                            && fill.getAttribute("patternContentUnits").toLowerCase() === "objectboundingbox") {
                            bBox || (bBox = getUntransformedBBox(node));
                            patternContentUnitsMatrix = new _pdf.Matrix(bBox[2], 0, 0, bBox[3], 0, 0);

                            fillBBox = fillData.boundingBox || getUntransformedBBox(fill);
                            x = fillBBox[0] / bBox[0];
                            y = fillBBox[1] / bBox[1];
                            width = fillBBox[2] / bBox[2];
                            height = fillBBox[3] / bBox[3];
                            fillData.boundingBox = [x, y, x + width, y + height];
                            fillData.xStep = width;
                            fillData.yStep = height;
                        }

                        fillData.matrix = _pdf.matrixMult(
                            _pdf.matrixMult(patternContentUnitsMatrix, patternUnitsMatrix), tfMatrix);

                        colorMode = "F";
                    } else {
                        // unsupported fill argument (e.g. patterns) -> fill black
                        fillUrl = fill = null;
                        setDefaultColor();
                    }
                } else {
                    // plain color
                    fillRGB = parseColor(fillColor);
                    if (fillRGB.ok) {
                        hasFillColor = true;
                        colorMode = 'F';
                    } else {
                        colorMode = null;
                    }
                }
            } else {
                // if no fill attribute is provided the default fill color is black
                setDefaultColor();
            }

            // opacity is realized via a pdf graphics state
            var opacity = 1.0;
            var nodeOpacity = node.getAttribute("opacity") || node.getAttribute("fill-opacity");
            if (nodeOpacity) {
                opacity *= parseFloat(nodeOpacity);
            }
            if (fillRGB && typeof fillRGB.a === "number") {
                opacity *= fillRGB.a;
            }
            _pdf.setGState(new _pdf.GState({opacity: opacity}));
        }

        if (nodeIs(node, "g,path,rect,ellipse,line,circle,polygon")) {
            // text has no fill color, so don't apply it until here
            if (hasFillColor) {
                _pdf.setFillColor(fillRGB.r, fillRGB.g, fillRGB.b);
            }

            // stroke mode
            var strokeColor = node.getAttribute('stroke');
            if (strokeColor) {
                var strokeWidth;
                if (node.hasAttribute("stroke-width")) {
                    strokeWidth = Math.abs(parseFloat(node.getAttribute('stroke-width')));
                    _pdf.setLineWidth(strokeWidth);
                }
                var strokeRGB = new RGBColor(strokeColor);
                if (strokeRGB.ok) {
                    _pdf.setDrawColor(strokeRGB.r, strokeRGB.g, strokeRGB.b);
                    if (strokeWidth !== 0) {
                        // pdf spec states: "A line width of 0 denotes the thinnest line that can be rendered at device resolution:
                        // 1 device pixel wide". SVG, however, does not draw zero width lines.
                        colorMode = (colorMode || "") + "D";
                    }
                }
                if (node.hasAttribute("stroke-linecap")) {
                    _pdf.setLineCap(node.getAttribute("stroke-linecap"));
                }
                if (node.hasAttribute("stroke-linejoin")) {
                    _pdf.setLineJoin(node.getAttribute("stroke-linejoin"));
                }
                if (node.hasAttribute("stroke-dasharray")) {
                    _pdf.setLineDashPattern(
                        parseFloats(node.getAttribute("stroke-dasharray")),
                        parseInt(node.getAttribute("stroke-dashoffset")) || 0
                    );
                }
                if (node.hasAttribute("stroke-miterlimit")) {
                    _pdf.setLineMiterLimit(parseFloat(node.getAttribute("stroke-miterlimit")));
                }
            }
        }

        setTextProperties(node, fillRGB);

        // do the actual drawing
        switch (node.tagName.toLowerCase()) {
            case 'svg':
                svg(node, tfMatrix, defs, svgIdPrefix, withinDefs);
                break;
            case 'g':
                findAndRenderDefs(node, tfMatrix, defs, svgIdPrefix, withinDefs);
            case 'a':
            case "marker":
                renderChildren(node, tfMatrix, defs, svgIdPrefix, withinDefs);
                break;

            case 'defs':
                renderChildren(node, tfMatrix, defs, svgIdPrefix, true);
                break;

            case 'use':
                use(node, tfMatrix, svgIdPrefix);
                break;

            case 'line':
                line(node, tfMatrix);
                break;

            case 'rect':
                _pdf.setCurrentTransformationMatrix(tfMatrix);
                rect(node, colorMode, fillUrl, fillData);
                break;

            case 'ellipse':
                _pdf.setCurrentTransformationMatrix(tfMatrix);
                ellipse(node, colorMode, fillUrl, fillData);
                break;

            case 'circle':
                _pdf.setCurrentTransformationMatrix(tfMatrix);
                circle(node, colorMode, fillUrl, fillData);
                break;
            case 'text':
                text(node, tfMatrix, hasFillColor, fillRGB);
                break;

            case 'path':
                path(node, tfMatrix, svgIdPrefix, colorMode, fillUrl, fillData);
                break;

            case 'polygon':
                polygon(node, tfMatrix, colorMode, fillUrl, fillData);
                break;

            case 'image':
                _pdf.setCurrentTransformationMatrix(tfMatrix);
                image(node);
                break;

            case "lineargradient":
                putGradient(node, "axial", [
                    node.getAttribute("x1"),
                    node.getAttribute("y1"),
                    node.getAttribute("x2"),
                    node.getAttribute("y2")
                ], defs, svgIdPrefix);
                break;

            case "radialgradient":
                putGradient(node, "radial", [
                    node.getAttribute("fx") || node.getAttribute("cx"),
                    node.getAttribute("fy") || node.getAttribute("cy"),
                    0,
                    node.getAttribute("cx") || 0,
                    node.getAttribute("cy") || 0,
                    node.getAttribute("r") || 0
                ], defs, svgIdPrefix);
                break;

            case "pattern":
                pattern(node, defs, svgIdPrefix);
                break;
        }

        // close either the formObject or the graphics context
        if (targetIsFormObject) {
            _pdf.endFormObject(svgIdPrefix.get() + node.getAttribute("id"));
        } else {
            _pdf.restoreGraphicsState();
        }
    };

    // the actual svgToPdf function (see above)
    var svg2pdf = function (element, pdf, options) {
        _pdf = pdf;

        var k = options.scale || 1.0,
            xOffset = options.xOffset || 0.0,
            yOffset = options.yOffset || 0.0;

        // set offsets and scale everything by k
        _pdf.saveGraphicsState();
        _pdf.setCurrentTransformationMatrix(new _pdf.Matrix(k, 0, 0, k, xOffset, yOffset));

        renderNode(element.cloneNode(true), _pdf.unitMatrix, {}, new SvgPrefix(""), false);

        _pdf.restoreGraphicsState();

        return _pdf;
    };

    if (typeof define === "function" && define.amd) {
        define(["rgbcolor"], function (rgbcolor) {
            RGBColor = rgbcolor;
            return svg2pdf;
        });
    } else if (typeof module !== "undefined" && module.exports) {
        RGBColor = require("./rgbcolor.js");
        module.exports = svg2pdf;
    } else {
        RGBColor = global.RGBColor;
        global.svg2pdf = svg2pdf;
        // for compatibility reasons
        global.svgElementToPdf = svg2pdf;
    }
    return svg2pdf;
}(typeof self !== "undefined" && self || typeof window !== "undefined" && window || this));
